{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"FullyConnectedNets.ipynb","provenance":[],"collapsed_sections":[]},"kernelspec":{"name":"python3","display_name":"Python 3"}},"cells":[{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"vXSoK_7l6e4R","executionInfo":{"status":"ok","timestamp":1616352089703,"user_tz":-60,"elapsed":2023,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"a405ec16-b969-4dbf-b4ae-b10f4942b571"},"source":["# this mounts your Google Drive to the Colab VM.\n","from google.colab import drive\n","drive.mount('/content/drive', force_remount=True)\n","\n","# enter the foldername in your Drive where you have saved the unzipped\n","# assignment folder, e.g. 'cs231n/assignments/assignment3/'\n","FOLDERNAME = 'cs231n/assignments/assignment2/'\n","assert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n","\n","# now that we've mounted your Drive, this ensures that\n","# the Python interpreter of the Colab VM can load\n","# python files from within it.\n","import sys\n","sys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n","\n","# this downloads the CIFAR-10 dataset to your Drive\n","# if it doesn't already exist.\n","%cd drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n","!bash get_datasets.sh\n","%cd /content"],"execution_count":3,"outputs":[{"output_type":"stream","text":["Mounted at /content/drive\n","/content/drive/My Drive/cs231n/assignments/assignment2/cs231n/datasets\n","/content\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"tags":["pdf-title"],"id":"5QKqv7me6e4a"},"source":["# Fully-Connected Neural Nets\n","In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures."]},{"cell_type":"markdown","metadata":{"tags":["pdf-ignore"],"id":"tNpLWKxl6e4b"},"source":["In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n","\n","```python\n","def layer_forward(x, w):\n","  \"\"\" Receive inputs x and weights w \"\"\"\n","  # Do some computations ...\n","  z = # ... some intermediate value\n","  # Do some more computations ...\n","  out = # the output\n","   \n","  cache = (x, w, z, out) # Values we need to compute gradients\n","   \n","  return out, cache\n","```\n","\n","The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n","\n","```python\n","def layer_backward(dout, cache):\n","  \"\"\"\n","  Receive dout (derivative of loss with respect to outputs) and cache,\n","  and compute derivative with respect to inputs.\n","  \"\"\"\n","  # Unpack cache values\n","  x, w, z, out = cache\n","  \n","  # Use values in cache to compute derivatives\n","  dx = # Derivative of loss with respect to x\n","  dw = # Derivative of loss with respect to w\n","  \n","  return dx, dw\n","```\n","\n","After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n","\n","In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n","  "]},{"cell_type":"code","metadata":{"tags":["pdf-ignore"],"colab":{"base_uri":"https://localhost:8080/"},"id":"PRBSw5jZ6e4c","executionInfo":{"status":"ok","timestamp":1616352095581,"user_tz":-60,"elapsed":2028,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"70cb8989-0c7e-420f-f7be-2be4cfaf3e11"},"source":["# As usual, a bit of setup\n","from __future__ import print_function\n","import time\n","import numpy as np\n","import matplotlib.pyplot as plt\n","from cs231n.classifiers.fc_net import *\n","from cs231n.data_utils import get_CIFAR10_data\n","from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n","from cs231n.solver import Solver\n","\n","%matplotlib inline\n","plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n","plt.rcParams['image.interpolation'] = 'nearest'\n","plt.rcParams['image.cmap'] = 'gray'\n","\n","# for auto-reloading external modules\n","# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n","%load_ext autoreload\n","%autoreload 2\n","\n","def rel_error(x, y):\n","  \"\"\" returns relative error \"\"\"\n","  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"],"execution_count":4,"outputs":[{"output_type":"stream","text":["=========== You can safely ignore the message below if you are NOT working on ConvolutionalNetworks.ipynb ===========\n","\tYou will need to compile a Cython extension for a portion of this assignment.\n","\tThe instructions to do this will be given in a section of the notebook below.\n","\tThere will be an option for Colab users and another for Jupyter (local) users.\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"tags":["pdf-ignore"],"colab":{"base_uri":"https://localhost:8080/"},"id":"N0LMWgTK6e4c","executionInfo":{"status":"ok","timestamp":1616352104749,"user_tz":-60,"elapsed":6426,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"86273c83-ec64-4d05-af05-68053e25258f"},"source":["# Load the (preprocessed) CIFAR10 data.\n","\n","data = get_CIFAR10_data()\n","for k, v in list(data.items()):\n","  print(('%s: ' % k, v.shape))"],"execution_count":5,"outputs":[{"output_type":"stream","text":["('X_train: ', (49000, 3, 32, 32))\n","('y_train: ', (49000,))\n","('X_val: ', (1000, 3, 32, 32))\n","('y_val: ', (1000,))\n","('X_test: ', (1000, 3, 32, 32))\n","('y_test: ', (1000,))\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"KTLvACOC6e4d"},"source":["# Affine layer: forward\n","Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n","\n","Once you are done you can test your implementaion by running the following:"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"5DbX3bvm6e4d","executionInfo":{"status":"ok","timestamp":1616352109522,"user_tz":-60,"elapsed":758,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"8b8ea0f3-f49f-4ed8-d7f4-a1ecf73757e6"},"source":["# Test the affine_forward function\n","\n","num_inputs = 2\n","input_shape = (4, 5, 6)\n","output_dim = 3\n","\n","input_size = num_inputs * np.prod(input_shape)\n","weight_size = output_dim * np.prod(input_shape)\n","\n","x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n","w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n","b = np.linspace(-0.3, 0.1, num=output_dim)\n","\n","out, _ = affine_forward(x, w, b)\n","correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n","                        [ 3.25553199,  3.5141327,   3.77273342]])\n","\n","# Compare your output with ours. The error should be around e-9 or less.\n","print('Testing affine_forward function:')\n","print('difference: ', rel_error(out, correct_out))"],"execution_count":6,"outputs":[{"output_type":"stream","text":["Testing affine_forward function:\n","difference:  9.769849468192957e-10\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"KnjPBdAE6e4e"},"source":["# Affine layer: backward\n","Now implement the `affine_backward` function and test your implementation using numeric gradient checking."]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"KBkX9RyS6e4e","executionInfo":{"status":"ok","timestamp":1616343057642,"user_tz":-60,"elapsed":1062,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"3ae83318-e163-4615-c880-80fc6c961358"},"source":["# Test the affine_backward function\n","np.random.seed(231)\n","x = np.random.randn(10, 2, 3)\n","w = np.random.randn(6, 5)\n","b = np.random.randn(5)\n","dout = np.random.randn(10, 5)\n","\n","dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n","dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n","db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n","\n","_, cache = affine_forward(x, w, b)\n","dx, dw, db = affine_backward(dout, cache)\n","\n","# The error should be around e-10 or less\n","print('Testing affine_backward function:')\n","print('dx error: ', rel_error(dx_num, dx))\n","print('dw error: ', rel_error(dw_num, dw))\n","print('db error: ', rel_error(db_num, db))"],"execution_count":5,"outputs":[{"output_type":"stream","text":["Testing affine_backward function:\n","dx error:  5.399100368651805e-11\n","dw error:  9.904211865398145e-11\n","db error:  2.4122867568119087e-11\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"UsHcjAaR6e4f"},"source":["# ReLU activation: forward\n","Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"U5v1vyA86e4g","executionInfo":{"status":"ok","timestamp":1616343060396,"user_tz":-60,"elapsed":889,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"93a5405c-d14c-4e64-f5be-3b2290808b85"},"source":["# Test the relu_forward function\n","\n","x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n","\n","out, _ = relu_forward(x)\n","correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n","                        [ 0.,          0.,          0.04545455,  0.13636364,],\n","                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n","\n","# Compare your output with ours. The error should be on the order of e-8\n","print('Testing relu_forward function:')\n","print('difference: ', rel_error(out, correct_out))"],"execution_count":6,"outputs":[{"output_type":"stream","text":["Testing relu_forward function:\n","difference:  4.999999798022158e-08\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"AhXkZzZB6e4h"},"source":["# ReLU activation: backward\n","Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"nFvwFIwD6e4i","executionInfo":{"status":"ok","timestamp":1616343063712,"user_tz":-60,"elapsed":933,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"c88a7dce-c1cc-41f4-e335-114489bfbf47"},"source":["np.random.seed(231)\n","x = np.random.randn(10, 10)\n","dout = np.random.randn(*x.shape)\n","\n","dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n","\n","_, cache = relu_forward(x)\n","dx = relu_backward(dout, cache)\n","\n","# The error should be on the order of e-12\n","print('Testing relu_backward function:')\n","print('dx error: ', rel_error(dx_num, dx))"],"execution_count":7,"outputs":[{"output_type":"stream","text":["Testing relu_backward function:\n","dx error:  3.2756349136310288e-12\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"tags":["pdf-inline"],"id":"t3tPd2VH6e4i"},"source":["## Inline Question 1: \n","\n","We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n","1. Sigmoid\n","2. ReLU\n","3. Leaky ReLU\n","\n","## Answer:\n","Activation functions that lead the gradient to get zero (or close to it) are **Sigmoid** and **ReLU**.\n","\n","Note that these activation functions could lead the gradient to zero partially or totally, it depends on the input values.\n","\n","One dimensional input that leads to this behavior:\n","- For the **Sigmoid**: Whatever neuron values will be (positive or negative, small or large), this activation function could lead the gradient to get zero (or close), a.k.a. Vanishing gradients. For that, any \"random\" example is correct, e.g. the input equals $[10, 3, 0.1, -0.05, -1, -5, ...]$.\n","- For the **ReLU**: By its definition, when neuron values are negative, e.g. the input equals $[-0.1, -0.5, -0.7, ...]$."]},{"cell_type":"markdown","metadata":{"id":"ARlWkAkk6e4j"},"source":["# \"Sandwich\" layers\n","There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n","\n","For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"nnIfVpCq6e4j","executionInfo":{"status":"ok","timestamp":1616343069123,"user_tz":-60,"elapsed":897,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"13adc039-0aac-4686-e6fa-0fc9518c0e31"},"source":["from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n","np.random.seed(231)\n","x = np.random.randn(2, 3, 4)\n","w = np.random.randn(12, 10)\n","b = np.random.randn(10)\n","dout = np.random.randn(2, 10)\n","\n","out, cache = affine_relu_forward(x, w, b)\n","dx, dw, db = affine_relu_backward(dout, cache)\n","\n","dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n","dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n","db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n","\n","# Relative error should be around e-10 or less\n","print('Testing affine_relu_forward and affine_relu_backward:')\n","print('dx error: ', rel_error(dx_num, dx))\n","print('dw error: ', rel_error(dw_num, dw))\n","print('db error: ', rel_error(db_num, db))"],"execution_count":8,"outputs":[{"output_type":"stream","text":["Testing affine_relu_forward and affine_relu_backward:\n","dx error:  2.299579177309368e-11\n","dw error:  8.162011105764925e-11\n","db error:  7.826724021458994e-12\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"SK-h9CRz6e4j"},"source":["# Loss layers: Softmax and SVM\n","You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n","\n","You can make sure that the implementations are correct by running the following:"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Nrop5UXF6e4k","executionInfo":{"status":"ok","timestamp":1616343072688,"user_tz":-60,"elapsed":885,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"6ebb06e1-e87b-4b47-9762-6566d9c3ac16"},"source":["np.random.seed(231)\n","num_classes, num_inputs = 10, 50\n","x = 0.001 * np.random.randn(num_inputs, num_classes)\n","y = np.random.randint(num_classes, size=num_inputs)\n","\n","dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n","loss, dx = svm_loss(x, y)\n","\n","# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n","print('Testing svm_loss:')\n","print('loss: ', loss)\n","print('dx error: ', rel_error(dx_num, dx))\n","\n","dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n","loss, dx = softmax_loss(x, y)\n","\n","# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n","print('\\nTesting softmax_loss:')\n","print('loss: ', loss)\n","print('dx error: ', rel_error(dx_num, dx))"],"execution_count":9,"outputs":[{"output_type":"stream","text":["Testing svm_loss:\n","loss:  8.999602749096233\n","dx error:  1.4021566006651672e-09\n","\n","Testing softmax_loss:\n","loss:  2.302545844500738\n","dx error:  9.384673161989355e-09\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"A9uMrfou6e4l"},"source":["# Two-layer network\n","In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n","\n","Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"n05qKD9K6e4m","executionInfo":{"status":"ok","timestamp":1616343079234,"user_tz":-60,"elapsed":1221,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"cdcca0d7-2d36-44a8-da13-5286523ec855"},"source":["np.random.seed(231)\n","N, D, H, C = 3, 5, 50, 7\n","X = np.random.randn(N, D)\n","y = np.random.randint(C, size=N)\n","\n","std = 1e-3\n","model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n","\n","print('Testing initialization ... ')\n","W1_std = abs(model.params['W1'].std() - std)\n","b1 = model.params['b1']\n","W2_std = abs(model.params['W2'].std() - std)\n","b2 = model.params['b2']\n","assert W1_std < std / 10, 'First layer weights do not seem right'\n","assert np.all(b1 == 0), 'First layer biases do not seem right'\n","assert W2_std < std / 10, 'Second layer weights do not seem right'\n","assert np.all(b2 == 0), 'Second layer biases do not seem right'\n","\n","print('Testing test-time forward pass ... ')\n","model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n","model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n","model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n","model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n","X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n","scores = model.loss(X)\n","correct_scores = np.asarray(\n","  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n","   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n","   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n","scores_diff = np.abs(scores - correct_scores).sum()\n","assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n","\n","print('Testing training loss (no regularization)')\n","y = np.asarray([0, 5, 1])\n","loss, grads = model.loss(X, y)\n","correct_loss = 3.4702243556\n","assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n","\n","model.reg = 1.0\n","loss, grads = model.loss(X, y)\n","correct_loss = 26.5948426952\n","assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n","\n","# Errors should be around e-7 or less\n","for reg in [0.0, 0.7]:\n","  print('Running numeric gradient check with reg = ', reg)\n","  model.reg = reg\n","  loss, grads = model.loss(X, y)\n","\n","  for name in sorted(grads):\n","    f = lambda _: model.loss(X, y)[0]\n","    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n","    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"],"execution_count":10,"outputs":[{"output_type":"stream","text":["Testing initialization ... \n","Testing test-time forward pass ... \n","Testing training loss (no regularization)\n","Running numeric gradient check with reg =  0.0\n","W1 relative error: 1.52e-08\n","W2 relative error: 3.21e-10\n","b1 relative error: 8.37e-09\n","b2 relative error: 4.33e-10\n","Running numeric gradient check with reg =  0.7\n","W1 relative error: 2.53e-07\n","W2 relative error: 2.85e-08\n","b1 relative error: 1.56e-08\n","b2 relative error: 7.76e-10\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"tIdex2q56e4n"},"source":["# Solver\n","In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n","\n","Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set."]},{"cell_type":"code","metadata":{"id":"tln_solver_accuracy","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1612461885396,"user_tz":-60,"elapsed":715226,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"7a39f8c3-b236-48b8-c348-f940daa1bef6"},"source":["model = TwoLayerNet()\n","solver = None\n","\n","##############################################################################\n","# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n","# 50% accuracy on the validation set.                                        #\n","##############################################################################\n","# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n","\n","# As explained in the course lectures, random search is a better strategy for\n","# hyperparameters tuning than the grid search.\n","def params_random_values(lr_range, reg_range, hidden_dim_range, epochs_range):\n","  lr = np.random.uniform(*lr_range)\n","  reg = np.random.uniform(*reg_range)\n","  hidden_dim = np.random.randint(*hidden_dim_range)\n","  epochs = np.random.randint(*epochs_range)\n","\n","  return lr, reg, hidden_dim, epochs\n","\n","# Define parameter values ranges for random search.\n","# Note that these ranges were adjusted during tests.\n","lr_range = (3e-4, 6e-4)\n","reg_range = (1, 2)\n","hidden_dim_range = (100, 200)\n","epochs_range = (10, 20)\n","\n","# Generate 5 random parameter values combinations.\n","# Note that combinations number was adjusted during tests.\n","test_params_values = []\n","for _ in range(5):\n","  curr_comb = params_random_values(lr_range, reg_range, hidden_dim_range, epochs_range)\n","  test_params_values.append(curr_comb)\n","\n","# Keep track of the best solver (such with the highest validation accuracy) during tests.\n","best_accuracy, best_solver = 0.0, None\n","\n","# Test each combination.\n","for idx, params_value in enumerate(test_params_values):\n","  lr, reg, hidden_dim, epochs = params_value\n","\n","  model = TwoLayerNet(reg=reg, hidden_dim=hidden_dim)\n","  solver = Solver(model, data,\n","                  update_rule='sgd',\n","                  optim_config={'learning_rate': lr},\n","                  lr_decay=0.9, num_epochs=epochs,\n","                  batch_size=100, verbose=False)\n","\n","  solver.train()\n","\n","  print('%2d) lr = %.2e | reg = %.3f | hidden_dim = %3d | epochs = %2d | ' \n","        % (idx+1, *params_value) + 'Accuracy = %.4f' % solver.best_val_acc)\n","\n","  if solver.best_val_acc > best_accuracy:\n","    best_accuracy = solver.best_val_acc\n","    best_solver = solver\n","\n","# Mark the best solver as the main one.\n","solver = best_solver\n","\n","print('\\nBest solver accuracy on the validation set is: %.4f' % solver.best_val_acc)\n","\n","# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n","##############################################################################\n","#                             END OF YOUR CODE                               #\n","##############################################################################"],"execution_count":null,"outputs":[{"output_type":"stream","text":[" 1) lr = 3.85e-04 | reg = 1.418 | hidden_dim = 169 | epochs = 16 | Accuracy = 0.5120\n"," 2) lr = 5.33e-04 | reg = 1.191 | hidden_dim = 171 | epochs = 14 | Accuracy = 0.5300\n"," 3) lr = 3.70e-04 | reg = 1.388 | hidden_dim = 141 | epochs = 17 | Accuracy = 0.5090\n"," 4) lr = 3.48e-04 | reg = 2.006 | hidden_dim = 173 | epochs = 11 | Accuracy = 0.4930\n"," 5) lr = 2.66e-04 | reg = 1.816 | hidden_dim = 119 | epochs = 10 | Accuracy = 0.4910\n","\n","Best solver accuracy on the validation set is: 0.5300\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"KpUtXsgI6e4o","colab":{"base_uri":"https://localhost:8080/","height":730},"executionInfo":{"status":"ok","timestamp":1612461937263,"user_tz":-60,"elapsed":1065,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"847048ab-9b1d-4f67-c5db-f0f9f02e16b4"},"source":["# Run this cell to visualize training loss and train / val accuracy\n","\n","plt.subplot(2, 1, 1)\n","plt.title('Training loss')\n","plt.plot(solver.loss_history, 'o')\n","plt.xlabel('Iteration')\n","\n","plt.subplot(2, 1, 2)\n","plt.title('Accuracy')\n","plt.plot(solver.train_acc_history, '-o', label='train')\n","plt.plot(solver.val_acc_history, '-o', label='val')\n","plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n","plt.xlabel('Epoch')\n","plt.legend(loc='lower right')\n","plt.gcf().set_size_inches(15, 12)\n","plt.show()"],"execution_count":null,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 1080x864 with 2 Axes>"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"XYhloSR86e4p"},"source":["# Multilayer network\n","Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n","\n","Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n","\n","Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."]},{"cell_type":"markdown","metadata":{"id":"BQbU47MT6e4p"},"source":["## Initial loss and gradient check\n","\n","As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n","\n","For gradient checking, you should expect to see errors around 1e-7 or less."]},{"cell_type":"code","metadata":{"id":"cdH0FRuk6e4q","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1616343131816,"user_tz":-60,"elapsed":2607,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"223727e5-82ab-4e68-8b23-8afa9cef6015"},"source":["np.random.seed(231)\n","N, D, H1, H2, C = 2, 15, 20, 30, 10\n","X = np.random.randn(N, D)\n","y = np.random.randint(C, size=(N,))\n","\n","for reg in [0, 3.14]:\n","  print('Running check with reg = ', reg)\n","  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n","                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n","\n","  loss, grads = model.loss(X, y)\n","  print('Initial loss: ', loss)\n","  \n","  # Most of the errors should be on the order of e-7 or smaller.   \n","  # NOTE: It is fine however to see an error for W2 on the order of e-5\n","  # for the check when reg = 0.0\n","  for name in sorted(grads):\n","    f = lambda _: model.loss(X, y)[0]\n","    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n","    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"],"execution_count":11,"outputs":[{"output_type":"stream","text":["Running check with reg =  0\n","Initial loss:  2.3004790897684924\n","W1 relative error: 1.48e-07\n","W2 relative error: 2.21e-05\n","W3 relative error: 3.53e-07\n","b1 relative error: 5.38e-09\n","b2 relative error: 2.09e-09\n","b3 relative error: 5.80e-11\n","Running check with reg =  3.14\n","Initial loss:  7.052114776533016\n","W1 relative error: 6.86e-09\n","W2 relative error: 3.52e-08\n","W3 relative error: 1.32e-08\n","b1 relative error: 1.48e-08\n","b2 relative error: 1.72e-09\n","b3 relative error: 1.80e-10\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"Sr-8mTZo6e4q"},"source":["As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs."]},{"cell_type":"code","metadata":{"scrolled":false,"id":"s2kyKTaT6e4s","colab":{"base_uri":"https://localhost:8080/","height":713},"executionInfo":{"status":"ok","timestamp":1616344360609,"user_tz":-60,"elapsed":15088,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"7953b900-4db6-47a3-aba9-6fdb554f8677"},"source":["# TODO: Use a three-layer Net to overfit 50 training examples by \n","# tweaking just the learning rate and initialization scale.\n","\n","num_train = 50\n","small_data = {\n","  'X_train': data['X_train'][:num_train],\n","  'y_train': data['y_train'][:num_train],\n","  'X_val': data['X_val'],\n","  'y_val': data['y_val'],\n","}\n","\n","best_accuracy, best_solver = 0.0, None\n","\n","# Generate 10 random values of 'weight_scale' and 'learning_rate'.\n","# Note that the range (for both hyperparameters) was adjusted during tests.\n","num_combinations = 10\n","\n","weight_scale_values = np.random.uniform(9e-3, 1e-2, num_combinations)\n","learning_rate_values = np.random.uniform(7e-3, 9e-3, num_combinations)\n","\n","for idx in range(num_combinations):\n","  weight_scale = weight_scale_values[idx]\n","  learning_rate = learning_rate_values[idx]\n","\n","  model = FullyConnectedNet([100, 100],\n","                weight_scale=weight_scale, dtype=np.float64)\n","  solver = Solver(model, small_data,\n","                  print_every=10, num_epochs=20, batch_size=25,\n","                  update_rule='sgd',\n","                  optim_config={\n","                    'learning_rate': learning_rate,\n","                  },\n","                  verbose=False\n","          )\n","  \n","  solver.train()\n","\n","  train_acc = solver.check_accuracy(small_data['X_train'], small_data['y_train'],\n","                                    batch_size=num_train)\n","\n","  print('%2d) weight_scale = %.2e | learning_rate = %.2e ' % (idx+1, weight_scale, learning_rate) +\n","        '| Accuracy = %.4f' % train_acc)\n","\n","  if train_acc > best_accuracy:\n","    best_accuracy = train_acc\n","    best_solver = solver\n","\n","solver = best_solver\n","print('\\nBest solver accuracy on the train set is: %.4f' % best_accuracy)\n","\n","plt.plot(solver.loss_history, 'o')\n","plt.title('Training loss history')\n","plt.xlabel('Iteration')\n","plt.ylabel('Training loss')\n","plt.show()"],"execution_count":31,"outputs":[{"output_type":"stream","text":[" 1) weight_scale = 9.96e-03 | learning_rate = 8.92e-03 | Accuracy = 0.8400\n"," 2) weight_scale = 9.45e-03 | learning_rate = 7.44e-03 | Accuracy = 0.9600\n"," 3) weight_scale = 9.09e-03 | learning_rate = 8.65e-03 | Accuracy = 0.7000\n"," 4) weight_scale = 9.21e-03 | learning_rate = 8.17e-03 | Accuracy = 0.9600\n"," 5) weight_scale = 9.81e-03 | learning_rate = 8.45e-03 | Accuracy = 0.9400\n"," 6) weight_scale = 9.88e-03 | learning_rate = 7.88e-03 | Accuracy = 1.0000\n"," 7) weight_scale = 9.37e-03 | learning_rate = 7.31e-03 | Accuracy = 1.0000\n"," 8) weight_scale = 9.60e-03 | learning_rate = 8.90e-03 | Accuracy = 0.7400\n"," 9) weight_scale = 9.40e-03 | learning_rate = 8.39e-03 | Accuracy = 0.9400\n","10) weight_scale = 9.50e-03 | learning_rate = 8.74e-03 | Accuracy = 0.9800\n","\n","Best solver accuracy on the train set is: 1.0000\n"],"name":"stdout"},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 720x576 with 1 Axes>"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"m2IfmatP6e4s"},"source":["Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs."]},{"cell_type":"code","metadata":{"id":"XKrICJRn6e4s","colab":{"base_uri":"https://localhost:8080/","height":713},"executionInfo":{"status":"ok","timestamp":1616343890741,"user_tz":-60,"elapsed":16976,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"e5c09acf-2fc0-4ef5-d144-9044f31534fb"},"source":["# TODO: Use a five-layer Net to overfit 50 training examples by \n","# tweaking just the learning rate and initialization scale.\n","\n","num_train = 50\n","small_data = {\n","  'X_train': data['X_train'][:num_train],\n","  'y_train': data['y_train'][:num_train],\n","  'X_val': data['X_val'],\n","  'y_val': data['y_val'],\n","}\n","\n","best_accuracy, best_solver = 0.0, None\n","\n","# Generate 10 random values of 'weight_scale' and 'learning_rate'.\n","# Note that the range (for both hyperparameters) was adjusted during tests.\n","num_combinations = 10\n","\n","weight_scale_values = np.random.uniform(9e-2, 1e-1, num_combinations)\n","learning_rate_values = np.random.uniform(1e-3, 4e-3, num_combinations)\n","\n","for idx in range(num_combinations):\n","  weight_scale = weight_scale_values[idx]\n","  learning_rate = learning_rate_values[idx]\n","\n","  model = FullyConnectedNet([100, 100, 100, 100],\n","                  weight_scale=weight_scale, dtype=np.float64)\n","  solver = Solver(model, small_data,\n","                  print_every=10, num_epochs=20, batch_size=25,\n","                  update_rule='sgd',\n","                  optim_config={\n","                    'learning_rate': learning_rate,\n","                  },\n","                  verbose=False\n","          )\n","  \n","  solver.train()\n","\n","  train_acc = solver.check_accuracy(small_data['X_train'], small_data['y_train'],\n","                                    batch_size=num_train)\n","\n","  print('%2d) weight_scale = %.2e | learning_rate = %.2e ' % (idx+1, weight_scale, learning_rate) +\n","        '| Accuracy = %.4f' % train_acc)\n","\n","  if train_acc > best_accuracy:\n","    best_accuracy = train_acc\n","    best_solver = solver\n","\n","solver = best_solver\n","print('\\nBest solver accuracy on the train set is: %.4f' % best_accuracy)\n","\n","plt.plot(solver.loss_history, 'o')\n","plt.title('Training loss history')\n","plt.xlabel('Iteration')\n","plt.ylabel('Training loss')\n","plt.show()"],"execution_count":28,"outputs":[{"output_type":"stream","text":[" 1) weight_scale = 9.26e-02 | learning_rate = 3.83e-03 | Accuracy = 0.7000\n"," 2) weight_scale = 9.59e-02 | learning_rate = 1.55e-03 | Accuracy = 0.2200\n"," 3) weight_scale = 9.48e-02 | learning_rate = 2.32e-03 | Accuracy = 0.8800\n"," 4) weight_scale = 9.76e-02 | learning_rate = 2.07e-03 | Accuracy = 0.9600\n"," 5) weight_scale = 9.71e-02 | learning_rate = 3.56e-03 | Accuracy = 0.4400\n"," 6) weight_scale = 9.44e-02 | learning_rate = 3.88e-03 | Accuracy = 0.9200\n"," 7) weight_scale = 9.38e-02 | learning_rate = 1.62e-03 | Accuracy = 1.0000\n"," 8) weight_scale = 9.15e-02 | learning_rate = 1.90e-03 | Accuracy = 0.9200\n"," 9) weight_scale = 9.26e-02 | learning_rate = 1.44e-03 | Accuracy = 1.0000\n","10) weight_scale = 9.88e-02 | learning_rate = 2.39e-03 | Accuracy = 0.1600\n","\n","Best solver accuracy on the train set is: 1.0000\n"],"name":"stdout"},{"output_type":"display_data","data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAmQAAAHwCAYAAAAIDnN0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de5RedX3v8fenIegoakRShAQMKsZDtRobLVaPx6I1eCWH9ngpKq10pbbWS6WhxNNzhK52SRuPl56qq7EqWKmXoxjx0kbLxdupl2DQcDFHRJEMt1QIgkQN8Xv+ePboEDOTyWSe5zeZ5/1aa9bz7N/ev2d/57f2mnyyf/vZO1WFJEmS2vml1gVIkiQNOwOZJElSYwYySZKkxgxkkiRJjRnIJEmSGjOQSZIkNWYgkzRQSf4lyakzve0+1vDUJFtn+nMn2V8lefgE605J8ulB1SJpdor3IZO0N0nuHLd4H+DHwK5u+Q+r6vzBVzV9SZ4KvK+qFg9ofwUcW1XX7MdnnAtsraq/mLHCJM0aB7UuQNLsV1WHjL1P8l3gD6rq33bfLslBVXX3IGvT1CSZV1W79r6lpBacspQ0bWNTf0n+PMlNwHuSPDDJJ5JsS3Jb937xuD6XJvmD7v3vJflCkjd2234nyTOnue0xST6X5I4k/5bkbUneN8Xf4z91+9qe5Mokzxu37llJruo+dzTJn3Xth3W/2/Yktyb5fJLJ/qY+Pcm3uu3fliTjf6/ufZK8OcktSX6QZHOSRyVZBZwCnJHkziQfn0Ld5yZ5R5JPJfkh8NokNyeZN26bk5N8fSpjJKm/DGSS9teDgUOBhwCr6P1deU+3fDSwA/j7Sfr/OrAFOAz4W+BdY2FlH7f9Z+ArwIOAs4CXTKX4JPOBjwOfBn4ZeCVwfpKl3Sbvojctez/gUcDFXfvpwFZgIXA48DpgsmtAngM8HvhV4PnAij1s8wzgKcAjgAd0232/qtYB5wN/W1WHVNVzp1A3wO8Cfw3cD/jfwPe7fYx5CfDeSWqWNCAGMkn766fA66vqx1W1o6q+X1Ufqaq7quoOeoHgv0zS/7qqemc3nXYecAS9gDPlbZMcTS/s/M+q+klVfQG4cIr1Hw8cApzT9b0Y+ATwom79TuC4JPevqtuq6mvj2o8AHlJVO6vq8zX5RbnnVNX2qvoecAnw2D1ss5NeeHokvWt8r66qG6dZN8DHquqLVfXTqvoRvTF7MUCSQ+mFwn+epGZJA2Igk7S/tnX/2AOQ5D5J/iHJdUl+AHwOWDB+qmw3N429qaq7ureH7OO2RwK3jmsDuH6K9R8JXF9VPx3Xdh2wqHv/28CzgOuSfDbJE7v2tcA1wKeTXJvkzL3s56Zx7+9iD79jF6r+HngbcEuSdUnuP8264RfH4H3Ac5Pcl97Zt89PEvgkDZCBTNL+2v2s0OnAUuDXq+r+9KbgACaahpwJNwKHJrnPuLajptj3BuCo3a7/OhoYBaiqr1bVSfSmBdcDH+ra76iq06vqocDz6F2j9bT9/D2oqr+rql8DjqM3dbl6bNW+1L2nPlU1Cvw7cDK96cp/2t96Jc0MA5mkmXY/eteNbe+mxV7f7x1W1XXARuCsJAd3Z7GeO8XuX6Z3xuqMJPO7W2I8F/hA91mnJHlAVe0EfkBvipYkz0ny8O4attvp3Qbkp3vexdQkeXySX++uD/sh8KNxn3kz8NCp1L2X3bwXOAN4NHDB/tQraeYYyCTNtLcAI8B/AF8C/nVA+z0FeCK9C9f/CvggvfulTaqqfkIvyDyTXs1vB15aVd/sNnkJ8N1u+vXl3X4AjgX+DbiT3lmnt1fVJfv5O9wfeCdwG73px+/TmxqF3pcLjuu+Ubl+CnVP5KP0vnDx0d2meCU15I1hJc1JST4IfLOq+n6G7kCT5Nv0vjn6C/eSk9SGZ8gkzQnddN/DkvxSkhOBk+hd86Vxkvw2vWvLLt7btpIGxzv1S5orHkzvmqgH0bs/2B9V1aa2Jc0uSS6l92WBl+z27UxJjTllKUmS1JhTlpIkSY0ZyCRJkho7oK8hO+yww2rJkiWty5AkSdqryy677D+qauGe1h3QgWzJkiVs3LixdRmSJEl7leS6idY5ZSlJktSYgUySJKkxA5kkSVJjBjJJkqTGDGSSJEmNGcgkSZIaM5BJkiQ1ZiCTJElqzEAmSZLUmIFMkiSpMQOZJElSYwYySZKkxgxkkiRJjRnIJEmSGjOQSZIkNXZQ6wLmmvWbRlm7YQs3bN/BkQtGWL1iKSuXLWpdliRJmsUMZDNo/aZR1lywmR07dwEwun0Hay7YDGAokyRJE3LKcgat3bDlZ2FszI6du1i7YUujiiRJ0oHAQDaDbti+Y5/aJUmSwEA2o45cMLJP7ZIkSWAgm1GrVyxlZP68e7SNzJ/H6hVLG1UkSZIOBF7UP4PGLtz3W5aSJGlfGMhm2MpliwxgkiRpnzhlKUmS1JiBTJIkqTEDmSRJUmMGMkmSpMYMZJIkSY0ZyCRJkhozkEmSJDVmIJMkSWrMQCZJktSYgUySJKkxA5kkSVJjfQtkSd6d5JYkV+xh3elJKslh3XKS/F2Sa5J8I8nj+lWXJEnSbNPPM2TnAifu3pjkKOAZwPfGNT8TOLb7WQW8o491SZIkzSp9C2RV9Tng1j2sejNwBlDj2k4C3ls9XwIWJDmiX7VJkiTNJgO9hizJScBoVX19t1WLgOvHLW/t2iRJkua8gwa1oyT3AV5Hb7pyfz5nFb1pTY4++ugZqEySJKmtQZ4hexhwDPD1JN8FFgNfS/JgYBQ4aty2i7u2X1BV66pqeVUtX7hwYZ9LliRJ6r+BBbKq2lxVv1xVS6pqCb1pycdV1U3AhcBLu29bHg/cXlU3Dqo2SZKklvp524v3A/8OLE2yNclpk2z+KeBa4BrgncAf96suSZKk2aZv15BV1Yv2sn7JuPcFvKJftUiSJM1m3qlfkiSpMQOZJElSYwYySZKkxgxkkiRJjRnIJEmSGjOQSZIkNWYgkyRJasxAJkmS1JiBTJIkqTEDmSRJUmMGMkmSpMYMZJIkSY0ZyCRJkhozkEmSJDVmIJMkSWrMQCZJktSYgUySJKkxA5kkSVJjBjJJkqTGDGSSJEmNGcgkSZIaM5BJkiQ1ZiCTJElqzEAmSZLUmIFMkiSpMQOZJElSYwYySZKkxgxkkiRJjRnIJEmSGjOQSZIkNWYgkyRJasxAJkmS1JiBTJIkqTEDmSRJUmMGMkmSpMYMZJIkSY0ZyCRJkhozkEmSJDVmIJMkSWrMQCZJktSYgUySJKkxA5kkSVJjBjJJkqTGDGSSJEmNGcgkSZIa61sgS/LuJLckuWJc29ok30zyjSQfTbJg3Lo1Sa5JsiXJin7VJUmSNNv08wzZucCJu7V9BnhUVf0q8P+ANQBJjgNeCPxK1+ftSeb1sTZJkqRZo2+BrKo+B9y6W9unq+rubvFLwOLu/UnAB6rqx1X1HeAa4An9qk2SJGk2aXkN2cuAf+neLwKuH7dua9cmSZI05zUJZEn+O3A3cP40+q5KsjHJxm3bts18cZIkSQM28ECW5PeA5wCnVFV1zaPAUeM2W9y1/YKqWldVy6tq+cKFC/taqyRJ0iAMNJAlORE4A3heVd01btWFwAuT3CvJMcCxwFcGWZskSVIrB/Xrg5O8H3gqcFiSrcDr6X2r8l7AZ5IAfKmqXl5VVyb5EHAVvanMV1TVrn7VJkmSNJvk57OGB57ly5fXxo0bW5chSZK0V0kuq6rle1rnnfolSZIaM5BJkiQ1ZiCTJElqzEAmSZLUmIFMkiSpMQOZJElSYwYySZKkxgxkkiRJjRnIJEmSGjOQSZIkNWYgkyRJasxAJkmS1JiBTJIkqTEDmSRJUmMGMkmSpMYMZJIkSY0ZyCRJkhozkEmSJDVmIJMkSWrMQCZJktSYgUySJKkxA5kkSVJjBjJJkqTGDGSSJEmNGcgkSZIaM5BJkiQ1ZiCTJElqzEAmSZLUmIFMkiSpMQOZJElSYwYySZKkxgxkkiRJjRnIJEmSGjOQSZIkNWYgkyRJasxAJkmS1JiBTJIkqTEDmSRJUmMGMkmSpMYMZJIkSY0ZyCRJkhozkEmSJDVmIJMkSWrMQCZJktRY3wJZkncnuSXJFePaDk3ymSTf6l4f2LUnyd8luSbJN5I8rl91SZIkzTb9PEN2LnDibm1nAhdV1bHARd0ywDOBY7ufVcA7+liXJEnSrNK3QFZVnwNu3a35JOC87v15wMpx7e+tni8BC5Ic0a/aJEmSZpNBX0N2eFXd2L2/CTi8e78IuH7cdlu7NkmSpDmv2UX9VVVA7Wu/JKuSbEyycdu2bX2oTJIkabAGHchuHpuK7F5v6dpHgaPGbbe4a/sFVbWuqpZX1fKFCxf2tVhJkqRBGHQguxA4tXt/KvCxce0v7b5teTxw+7ipTUmSpDntoH59cJL3A08FDkuyFXg9cA7woSSnAdcBz+82/xTwLOAa4C7g9/tVlyRJ0mzTt0BWVS+aYNXT9rBtAa/oVy2SJEmzmXfqlyRJasxAJkmS1JiBTJIkqTEDmSRJUmMGMkmSpMYMZJIkSY0ZyCRJkhozkEmSJDVmIJMkSWrMQCZJktSYgUySJKkxA5kkSVJjBjJJkqTGDGSSJEmNGcgkSZIaM5BJkiQ1ZiCTJElqzEAmSZLUmIFMkiSpMQOZJElSYwYySZKkxgxkkiRJjRnIJEmSGjOQSZIkNWYgkyRJasxAJkmS1JiBTJIkqTEDmSRJUmMGMkmSpMYMZJIkSY0ZyCRJkhozkEmSJDVmIJMkSWrMQCZJktSYgUySJKkxA5kkSVJjew1kSZ6U5L7d+xcneVOSh/S/NEmSpOEwlTNk7wDuSvIY4HTg28B7+1qVJEnSEJlKILu7qgo4Cfj7qnobcL/+liVJkjQ8DprCNnckWQO8GHhKkl8C5ve3LEmSpOExlUD2AuB3gdOq6qYkRwNr+1vWcFm/aZS1G7Zww/YdHLlghNUrlrJy2aLWZUmSpAGZ0hky4K1VtSvJI4BHAu/vb1nDY/2mUdZcsJkdO3cBMLp9B2su2AxgKJMkaUhM5RqyzwH3SrII+DTwEuDcfhY1TNZu2PKzMDZmx85drN2wpVFFkiRp0KYSyFJVdwEnA2+vqv8GPKq/ZQ2PG7bv2Kd2SZI090wpkCV5InAK8Ml96KcpOHLByD61S5KkuWcqweo1wBrgo1V1ZZKHApfsz06T/GmSK5NckeT9Se6d5JgkX05yTZIPJjl4f/ZxoFi9Yikj8+fdo21k/jxWr1jaqCJJkjRoew1kVfXZqnoe8LYkh1TVtVX1qunusLsW7VXA8qp6FDAPeCHwN8Cbq+rhwG3AadPdx4Fk5bJFvOHkR7NowQgBFi0Y4Q0nP9oL+iVJGiJ7/ZZlkkfTuzP/ob3FbANeWlVX7ud+R5LsBO4D3AicQO/2GgDnAWfRe0rAnLdy2SIDmCRJQ2wqU5b/ALy2qh5SVUfTe3zSO6e7w6oaBd4IfI9eELsduAzYXlV3d5ttBUwokiRpKEwlkN23qn52zVhVXQrcd7o7TPJAeo9hOgY4svusE/eh/6okG5Ns3LZt23TLkCRJmjWmEsiuTfI/kizpfv4CuHY/9vl04DtVta2qdgIXAE8CFiQZm0JdDIzuqXNVrauq5VW1fOHChftRhiRJ0uwwlUD2MmAhveB0Qff+Zfuxz+8Bxye5T5IATwOuovfNzd/ptjkV+Nh+7EOSJOmAsdeL+qvqNnrfipwRVfXlJB8GvgbcDWwC1tG7x9kHkvxV1/aumdqnJEnSbDZhIEvycaAmWt/dCmNaqur1wOt3a74WeMJ0P1OSJOlANdkZsjcOrApJkqQhNmEgq6rPDrIQSZKkYeUzKSVJkhozkEmSJDVmIJMkSWpsKs+y3NO3LW8HNgL/UFU/6kdhkiRJw2JKd+oH7qT3/Mp3Aj8A7gAewX4801KSJEk9ez1DBvxGVT1+3PLHk3y1qh6f5Mp+FSZJkjQspnKG7JAkR48tdO8P6RZ/0peqJEmShshUzpCdDnwhybeBAMcAf5zkvsB5/SxOkiRpGEzlWZafSnIs8Miuacu4C/nf0rfKJEmShsRUzpAB/BqwpNv+MUmoqvf2rSpJkqQhMpXbXvwT8DDgcmBX11yAgUySJGkGTOUM2XLguKra/V5kkiRJmgFT+ZblFcCD+12IJEnSsJrKGbLDgKuSfAX48VhjVT2vb1Vpr9ZvGmXthi3csH0HRy4YYfWKpaxctqh1WZIkaRqmEsjO6ncRs9VsDT3rN42y5oLN7NjZu6RvdPsO1lywGWBW1CdJkvbNVG578dlBFDLbzObQs3bDlp/VNWbHzl2s3bCleW2SJGnfTXgNWZIvdK93JPnBuJ87kvxgcCW2MVnoae2G7Tv2qV2SJM1uE54hq6ond6/3G1w5s8dsDj1HLhhhdA91HLlgpEE1kiRpf03lW5YkmZfkyCRHj/30u7DWJgo3syH0rF6xlJH58+7RNjJ/HqtXLG1UkSRJ2h97DWRJXgncDHwG+GT384k+19XcbA49K5ct4g0nP5pFC0YIsGjBCG84+dFePyZJ0gFqKt+yfDWwtKq+3+9iZpOxcDMbv2UJvfpmSy2SJGn/TCWQXQ/c3u9CZiNDjyRJGoSpBLJrgUuTfJJ73hj2TX2rSpIkaYhMJZB9r/s5uPuRJEnSDJrKjWHPHkQhkiRJw2rCQJbkLVX1miQfB2r39T7LUpIkaWZMdobsn7rXNw6iEEmSpGE12Z36L+teh/JZlpIkSYOy12vIkhwLvAE4Drj3WHtVPbSPdUmSJA2NqTw66T3AO4C7gd8E3gu8r59FSZIkDZOpBLKRqroISFVdV1VnAc/ub1mSJEnDYyr3Iftxkl8CvpXkT4BR4JD+liVJkjQ8pnKG7NXAfYBXAb8GvBg4tZ9FSZIkDZNJz5AlmQe8oKr+DLgT+P2BVCVJkjREJjxDluSgqtoFPHmA9UiSJA2dyc6QfQV4HLApyYXA/wF+OLayqi7oc22SJElDYSoX9d8b+D5wAr1HKKV7NZBJkiTNgMkC2S8neS1wBT8PYmN+4dmWkiRJmp7JAtk8ere3yB7WGcgkSZJmyGSB7Maq+suBVSJJkjSkJrsP2Z7OjEmSJGmGTRbInjawKiRJkobYhIGsqm4dZCGSJEnDaiqPTppxSRYk+XCSbya5OskTkxya5DNJvtW9PrBFbZIkSYPWJJABbwX+taoeCTwGuBo4E7ioqo4FLuqWJUmS5ryBB7IkDwCeArwLoKp+UlXbgZOA87rNzgNWDro2SZKkFlqcITsG2Aa8J8mmJP+Y5L7A4VV1Y7fNTcDhe+qcZFWSjUk2btu2bUAlS5Ik9U+LQHYQvWdkvqOqltF7PuY9pierqpjg5rNVta6qllfV8oULF/a9WEmSpH5rEci2Alur6svd8ofpBbSbkxwB0L3e0qA2SZKkgRt4IKuqm4Drkyztmp4GXAVcCJzatZ0KfGzQtUmSJLUw2aOT+umVwPlJDgauBX6fXjj8UJLTgOuA5zeqTZIkaaCaBLKquhxYvodVPh1AkiQNnVb3IZMkSVLHQCZJktSYgUySJKkxA5kkSVJjBjJJkqTGDGSSJEmNGcgkSZIaM5BJkiQ1ZiCTJElqzEAmSZLUmIFMkiSpMQOZJElSYwYySZKkxgxkkiRJjRnIJEmSGjOQSZIkNWYgkyRJasxAJkmS1JiBTJIkqTEDmSRJUmMGMkmSpMYMZJIkSY0ZyCRJkhozkEmSJDVmIJMkSWrMQCZJktSYgUySJKkxA5kkSVJjBjJJkqTGDGSSJEmNGcgkSZIaM5BJkiQ1ZiCTJElqzEAmSZLUmIFMkiSpMQOZJElSYwYySZKkxgxkkiRJjRnIJEmSGjOQSZIkNWYgkyRJasxAJkmS1JiBTJIkqTEDmSRJUmPNAlmSeUk2JflEt3xMki8nuSbJB5Mc3Ko2SZKkQWp5huzVwNXjlv8GeHNVPRy4DTitSVWSJEkD1iSQJVkMPBv4x245wAnAh7tNzgNWtqhNkiRp0FqdIXsLcAbw0275QcD2qrq7W94KLGpRmCRJ0qANPJAleQ5wS1VdNs3+q5JsTLJx27ZtM1ydJEnS4LU4Q/Yk4HlJvgt8gN5U5VuBBUkO6rZZDIzuqXNVrauq5VW1fOHChYOoV5Ikqa8GHsiqak1VLa6qJcALgYur6hTgEuB3us1OBT426NokSZJamE33Iftz4LVJrqF3Tdm7GtcjSZI0EAftfZP+qapLgUu799cCT2hZjyRJUguz6QyZJEnSUDKQSZIkNWYgkyRJasxAJkmS1JiBTJIkqTEDmSRJUmMGMkmSpMYMZJIkSY0ZyCRJkhozkEmSJDVmIJMkSWrMQCZJktSYgUySJKkxA5kkSVJjBjJJkqTGDGSSJEmNGcgkSZIaM5BJkiQ1ZiCTJElqzEAmSZLUmIFMkiSpMQOZJElSYwYySZKkxgxkkiRJjRnIJEmSGjOQSZIkNWYgkyRJasxAJkmS1NhBrQvQ4KzfNMraDVu4YfsOjlwwwuoVS1m5bFHrsiRJGnoGsiGxftMoay7YzI6duwAY3b6DNRdsBjCUSZLUmFOWQ2Lthi0/C2NjduzcxdoNWxpVJEmSxhjIhsQN23fsU7skSRocA9mQOHLByD61S5KkwTGQDYnVK5YyMn/ePdpG5s9j9YqljSqSJEljvKh/SIxduO+3LCVJmn0MZENk5bJFBjBJkmYhpywlSZIaM5BJkiQ1ZiCTJElqzEAmSZLUmIFMkiSpMQOZJElSYwYySZKkxgxkkiRJjRnIJEmSGht4IEtyVJJLklyV5Mokr+7aD03ymSTf6l4fOOjaJEmSWmhxhuxu4PSqOg44HnhFkuOAM4GLqupY4KJuWZIkac4beCCrqhur6mvd+zuAq4FFwEnAed1m5wErB12bJElSC02vIUuyBFgGfBk4vKpu7FbdBBw+QZ9VSTYm2bht27aB1ClJktRPzQJZkkOAjwCvqaofjF9XVQXUnvpV1bqqWl5VyxcuXDiASiVJkvqrSSBLMp9eGDu/qi7omm9OckS3/gjglha1SZIkDVqLb1kGeBdwdVW9adyqC4FTu/enAh8bdG2SJEktHNRgn08CXgJsTnJ51/Y64BzgQ0lOA64Dnt+gNkmSpIEbeCCrqi8AmWD10wZZiyRJ0mzgnfolSZIaM5BJkiQ1ZiCTJElqzEAmSZLUmIFMkiSpMQOZJElSYwYySZKkxgxkkiRJjRnIJEmSGjOQSZIkNdbiWZY6gKzfNMraDVu4YfsOjlwwwuoVS1m5bFHrsiRJmlMMZJrQ+k2jrLlgMzt27gJgdPsO1lywGcBQJknSDHLKUhNau2HLz8LYmB07d7F2w5ZGFUmSNDcZyDShG7bv2Kd2SZI0PQYyTejIBSP71C5JkqbHQKYJrV6xlJH58+7RNjJ/HqtXLG1UkSRJc5MX9WtCYxfu+y1LSZL6y0CmSa1ctsgAJklSnzllKUmS1JiBTJIkqTEDmSRJUmMGMkmSpMa8qF+zgs/MlCQNMwOZmvOZmZKkYeeUpZrzmZmSpGFnIFNzPjNTkjTsDGRqzmdmSpKGnYFMzfnMTEnSsPOifjXnMzMlScPOQKZZwWdmSpKGmVOWkiRJjRnIJEmSGjOQSZIkNWYgkyRJasyL+nXA8vmXkqS5wkCmGTeIoOTzLyVJc4lTlppRY0FpdPsOip8HpfWbRmd0Pz7/UpI0lxjINKMGFZR8/qUkaS4xkGlGDSoo+fxLSdJcYiDTjBpUUPL5l5KkucRAphk1qKC0ctki3nDyo1m0YIQAixaM8IaTH+0F/ZKkA5LfstSMGuSDwn3+pSRprjCQacbN5qDkvcscA0majQxkGhrTvXfZoAKM92+TpOE1664hS3Jiki1JrklyZut6NHdM55Ycg7qv2my/f9v6TaM86ZyLOebMT/Kkcy6e8boGvR9Jmm1m1RmyJPOAtwG/BWwFvprkwqq6qm1lmgumc0uOyQLMTJ5VG9R+pjMGgzqzOMgzmPaxj33ssz99+mFWBTLgCcA1VXUtQJIPACcBBjLttyMXjDC6h+Ax2S05BhVgBrWf6YzBdMLidGob1H7sYx/72Gd/+vTLbJuyXARcP255a9cm7bfp3JJjOvdVm8604KD2M50xmOkzi633Yx/72Mc++9OnX2ZbINurJKuSbEyycdu2ba3L0QFkOvcuG1SAGdR+pjMG0wmL06ltUPuxj33sY5/96dMvsy2QjQJHjVte3LX9TFWtq6rlVbV84cKFAy1OB76VyxbxxTNP4DvnPJsvnnnCXk9JDyrADGo/Y/valzEY1JnFQe3HPvaxj332p0+/zLZA9lXg2CTHJDkYeCFwYeOaNOQGEWAGuZ99Nagzi4Paj33sYx/77E+ffpl31llnDXynEznrrLN+evbZZ38LOB94JfC+qvrIRNuvW7furFWrVg2sPmkqHnnE/Vn8wBE2j97OnT+6m0ULRvifzz1uxi8QHdR+xvZ12pOP4TVPfwSnPfkYHnnE/ftS2yD2Yx/72Mc++9Nnf5x99tk3nnXWWev2tC5V1ZedDsLy5ctr48aNrcuQJEnaqySXVdXyPa2bbVOWkiRJQ8dAJkmS1JiBTJIkqTEDmSRJUmMGMkmSpMYMZJIkSY0ZyCRJkhozkEmSJDVmIJMkSWrMQCZJktSYgUySJKkxA5kkSVJjBjJJkqTGDGSSJEmNGcgkSZIaS1W1rmHakmwDrhvArg4D/mMA+5nNHAPHABwDcAzAMQDHABwD2PcxeEhVLdzTigM6kA1Kko1Vtbx1HS05Bo4BOAbgGIBjAI4BOAYws2PglKUkSVJjBjJJkqTGDGRTs651AbOAY+AYgGMAjgE4BuAYgGMAMzgGXkMmSZLUmGfIJEmSGjOQTSLJiUm2JLkmyZmt62khyXeTbE5yeZKNresZhCTvTnJLkivGtR2a5DNJvtW9PrBljf02wRiclWS0OxYuT/KsljX2W5KjklyS5KokVyZ5ddc+NMfCJGMwNMdCknsn+UqSr3djcHbXfkySL3f/PnwwycGta+2XScbg3CTfGXccPLZ1rf2WZF6STUk+0S3P2HFgIJtAknnA24BnAscBL0pyXNuqmvnNqkhOsb4AAAV/SURBVHrsEH29+VzgxN3azgQuqqpjgYu65bnsXH5xDADe3B0Lj62qTw24pkG7Gzi9qo4Djgde0f0NGKZjYaIxgOE5Fn4MnFBVjwEeC5yY5Hjgb+iNwcOB24DTGtbYbxONAcDqccfB5e1KHJhXA1ePW56x48BANrEnANdU1bVV9RPgA8BJjWvSAFTV54Bbd2s+CTive38esHKgRQ3YBGMwVKrqxqr6Wvf+Dnp/hBcxRMfCJGMwNKrnzm5xfvdTwAnAh7v2uX4cTDQGQyXJYuDZwD92y2EGjwMD2cQWAdePW97KkP0h6hTw6SSXJVnVupiGDq+qG7v3NwGHtyymoT9J8o1uSnPOTtXtLskSYBnwZYb0WNhtDGCIjoVumupy4BbgM8C3ge1VdXe3yZz/92H3MaiqsePgr7vj4M1J7tWwxEF4C3AG8NNu+UHM4HFgINPePLmqHkdv6vYVSZ7SuqDWqvfV5KH73yHwDuBh9KYsbgT+V9tyBiPJIcBHgNdU1Q/GrxuWY2EPYzBUx0JV7aqqxwKL6c2ePLJxSQO3+xgkeRSwht5YPB44FPjzhiX2VZLnALdU1WX92oeBbGKjwFHjlhd3bUOlqka711uAj9L7YzSMbk5yBED3ekvjegauqm7u/ij/FHgnQ3AsJJlPL4icX1UXdM1DdSzsaQyG8VgAqKrtwCXAE4EFSQ7qVg3Nvw/jxuDEbkq7qurHwHuY28fBk4DnJfkuvUuYTgDeygweBwayiX0VOLb7BsXBwAuBCxvXNFBJ7pvkfmPvgWcAV0zea866EDi1e38q8LGGtTQxFkI6/5U5fix014e8C7i6qt40btXQHAsTjcEwHQtJFiZZ0L0fAX6L3rV0lwC/020214+DPY3BN8f9xyT0rp2as8dBVa2pqsVVtYReHri4qk5hBo8Dbww7ie6r3G8B5gHvrqq/blzSQCV5KL2zYgAHAf88DGOQ5P3AU4HDgJuB1wPrgQ8BRwPXAc+vqjl70fsEY/BUelNUBXwX+MNx11LNOUmeDHwe2MzPrxl5Hb1rqIbiWJhkDF7EkBwLSX6V3sXa8+idxPhQVf1l9/fxA/Sm6jYBL+7OFM05k4zBxcBCIMDlwMvHXfw/ZyV5KvBnVfWcmTwODGSSJEmNOWUpSZLUmIFMkiSpMQOZJElSYwYySZKkxgxkkiRJjRnIJB3wktzZvS5J8rsz/Nmv2235/87k50sSGMgkzS1LgH0KZOPusj2RewSyqvqNfaxJkvbKQCZpLjkH+M9JLk/yp90Dkdcm+Wr3AOQ/hN6NHZN8PsmFwFVd2/oklyW5Msmqru0cYKT7vPO7trGzcek++4okm5O8YNxnX5rkw0m+meT87k7mkjShvf3PUJIOJGfS3UEboAtWt1fV45PcC/hikk932z4OeFRVfadbfllV3do9GuarST5SVWcm+ZPuocq7O5ne3eofQ++JBl9N8rlu3TLgV4AbgC/Sew7eF2b+15U0V3iGTNJc9gzgpUkup/fIowcBx3brvjIujAG8KsnXgS8BR43bbiJPBt7fPWT7ZuCzwOPHffbW7uHbl9ObSpWkCXmGTNJcFuCVVbXhHo29Z9H9cLflpwNPrKq7klwK3Hs/9jv+WXa78G+tpL3wDJmkueQO4H7jljcAf5RkPkCSRyS57x76PQC4rQtjjwSOH7du51j/3XweeEF3ndpC4CnAV2bkt5A0dPxfm6S55BvArm7q8VzgrfSmC7/WXVi/DVi5h37/Crw8ydXAFnrTlmPWAd9I8rWqOmVc+0eBJwJfBwo4o6pu6gKdJO2TVFXrGiRJkoaaU5aSJEmNGcgkSZIaM5BJkiQ1ZiCTJElqzEAmSZLUmIFMkiSpMQOZJElSYwYySZKkxv4/6jzqF+MgCwIAAAAASUVORK5CYII=\n","text/plain":["<Figure size 720x576 with 1 Axes>"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"tags":["pdf-inline"],"id":"TiAXbzA16e4-"},"source":["## Inline Question 2: \n","Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n","\n","## Answer:\n","I run some tests on a range of the `weight_scale` parameter, from `1e-5` to `5e-1`. For the `learning_rate`, I picked the best one which allows overfitting a small dataset (individual for both **3-Layer** and **5-Layer** Nets). Results (validation accuracies) are shown in the table below.\n","\n","|        Weight scale        | 1e-5 | 5e-5 | 1e-4 | 5e-4 | 1e-3 | 5e-3 | 1e-2 | 5e-2 | 1e-1 | 5e-1 |\n","|:--------------------------:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|\n","|  3-Layer Net (lr=7.44e-03) | 0.16 | 0.12 | 0.10 | 0.10 | 0.16 | 0.72 | 0.98 | 0.40 | 0.12 | 0.16 |\n","|  5-Layer Net (lr=2.00e-03) | 0.16 | 0.16 | 0.12 | 0.16 | 0.16 | 0.18 | 0.18 | 0.98 | 0.78 |   -  |\n","\n","From the table above, we cannot decide which network is more sensitive to the initialization scale. Thus, we have to analyze the evolution of the loss (in the two graphs above).\n","\n","From the two graphs above, we notice that the **5-Layer Net** is more difficult to train, because the loss decreases quickly. For that, the **5-Layer Net** is more sensitive to the initialization scale. That's due to the fact that the **5-Layer Net** has more layers, which can lead (in the worst scenario) to one of the two cases:\n","- The **low** (e.g. 1e-4) init scale can lead to the **vanishing gradients** problem, as we multiply by **small values** in the backpropgation.\n","- The **high** (e.g. 1e-1) init scale can lead to the **exploding gradients** problem, as we multiply by **big values** in the backpropagation.\n","\n","Note that these two cases are likely to occur in the **3-Layer Net** also, but the **5-Layer Net** is more prone to these issues."]},{"cell_type":"markdown","metadata":{"id":"D4Mm_Hf86e4-"},"source":["# Update rules\n","So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."]},{"cell_type":"markdown","metadata":{"id":"0zPfUlx66e4-"},"source":["# SGD+Momentum\n","Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n","\n","Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."]},{"cell_type":"code","metadata":{"id":"DL6wvk8L6e4_","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1616348670626,"user_tz":-60,"elapsed":975,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"beb2fb0b-8faf-47a2-a392-a32dc36b817a"},"source":["from cs231n.optim import sgd_momentum\n","\n","N, D = 4, 5\n","w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n","dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n","v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n","\n","config = {'learning_rate': 1e-3, 'velocity': v}\n","next_w, _ = sgd_momentum(w, dw, config=config)\n","\n","expected_next_w = np.asarray([\n","  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n","  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n","  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n","  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n","expected_velocity = np.asarray([\n","  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n","  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n","  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n","  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n","\n","# Should see relative errors around e-8 or less\n","print('next_w error: ', rel_error(next_w, expected_next_w))\n","print('velocity error: ', rel_error(expected_velocity, config['velocity']))"],"execution_count":32,"outputs":[{"output_type":"stream","text":["next_w error:  8.882347033505819e-09\n","velocity error:  4.269287743278663e-09\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"lDaHzWI36e5A"},"source":["Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."]},{"cell_type":"code","metadata":{"scrolled":false,"id":"YsLEPP_46e5A","colab":{"base_uri":"https://localhost:8080/","height":1000},"executionInfo":{"status":"ok","timestamp":1612473276942,"user_tz":-60,"elapsed":8668,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"47758191-b438-48fe-a810-b466e9aaa698"},"source":["num_train = 4000\n","small_data = {\n","  'X_train': data['X_train'][:num_train],\n","  'y_train': data['y_train'][:num_train],\n","  'X_val': data['X_val'],\n","  'y_val': data['y_val'],\n","}\n","\n","solvers = {}\n","\n","for update_rule in ['sgd', 'sgd_momentum']:\n","  print('running with ', update_rule)\n","  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n","\n","  solver = Solver(model, small_data,\n","                  num_epochs=5, batch_size=100,\n","                  update_rule=update_rule,\n","                  optim_config={\n","                    'learning_rate': 5e-3,\n","                  },\n","                  verbose=True)\n","  solvers[update_rule] = solver\n","  solver.train()\n","  print()\n","\n","plt.subplot(3, 1, 1)\n","plt.title('Training loss')\n","plt.xlabel('Iteration')\n","\n","plt.subplot(3, 1, 2)\n","plt.title('Training accuracy')\n","plt.xlabel('Epoch')\n","\n","plt.subplot(3, 1, 3)\n","plt.title('Validation accuracy')\n","plt.xlabel('Epoch')\n","\n","for update_rule, solver in solvers.items():\n","  plt.subplot(3, 1, 1)\n","  plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n","  \n","  plt.subplot(3, 1, 2)\n","  plt.plot(solver.train_acc_history, '-o', label=\"train_acc_%s\" % update_rule)\n","\n","  plt.subplot(3, 1, 3)\n","  plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n","  \n","for i in [1, 2, 3]:\n","  plt.subplot(3, 1, i)\n","  plt.legend(loc='upper center', ncol=4)\n","plt.gcf().set_size_inches(15, 15)\n","plt.show()"],"execution_count":null,"outputs":[{"output_type":"stream","text":["running with  sgd\n","(Iteration 1 / 200) loss: 2.460194\n","(Epoch 0 / 5) train acc: 0.122000; val_acc: 0.105000\n","(Iteration 11 / 200) loss: 2.270591\n","(Iteration 21 / 200) loss: 2.274979\n","(Iteration 31 / 200) loss: 2.165625\n","(Epoch 1 / 5) train acc: 0.216000; val_acc: 0.216000\n","(Iteration 41 / 200) loss: 2.139597\n","(Iteration 51 / 200) loss: 2.097792\n","(Iteration 61 / 200) loss: 1.997002\n","(Iteration 71 / 200) loss: 2.042961\n","(Epoch 2 / 5) train acc: 0.279000; val_acc: 0.266000\n","(Iteration 81 / 200) loss: 2.069637\n","(Iteration 91 / 200) loss: 2.031380\n","(Iteration 101 / 200) loss: 1.981451\n","(Iteration 111 / 200) loss: 1.991929\n","(Epoch 3 / 5) train acc: 0.307000; val_acc: 0.292000\n","(Iteration 121 / 200) loss: 1.911158\n","(Iteration 131 / 200) loss: 1.953267\n","(Iteration 141 / 200) loss: 2.105554\n","(Iteration 151 / 200) loss: 2.109657\n","(Epoch 4 / 5) train acc: 0.338000; val_acc: 0.304000\n","(Iteration 161 / 200) loss: 1.882566\n","(Iteration 171 / 200) loss: 1.768357\n","(Iteration 181 / 200) loss: 1.800674\n","(Iteration 191 / 200) loss: 1.796057\n","(Epoch 5 / 5) train acc: 0.349000; val_acc: 0.305000\n","\n","running with  sgd_momentum\n","(Iteration 1 / 200) loss: 2.869109\n","(Epoch 0 / 5) train acc: 0.124000; val_acc: 0.124000\n","(Iteration 11 / 200) loss: 2.211370\n","(Iteration 21 / 200) loss: 2.070362\n","(Iteration 31 / 200) loss: 1.928417\n","(Epoch 1 / 5) train acc: 0.337000; val_acc: 0.295000\n","(Iteration 41 / 200) loss: 1.956824\n","(Iteration 51 / 200) loss: 1.925771\n","(Iteration 61 / 200) loss: 1.732797\n","(Iteration 71 / 200) loss: 1.704392\n","(Epoch 2 / 5) train acc: 0.419000; val_acc: 0.330000\n","(Iteration 81 / 200) loss: 1.663840\n","(Iteration 91 / 200) loss: 1.515460\n","(Iteration 101 / 200) loss: 1.520019\n","(Iteration 111 / 200) loss: 1.574483\n","(Epoch 3 / 5) train acc: 0.456000; val_acc: 0.327000\n","(Iteration 121 / 200) loss: 1.706847\n","(Iteration 131 / 200) loss: 1.336883\n","(Iteration 141 / 200) loss: 1.473617\n","(Iteration 151 / 200) loss: 1.483828\n","(Epoch 4 / 5) train acc: 0.522000; val_acc: 0.331000\n","(Iteration 161 / 200) loss: 1.268828\n","(Iteration 171 / 200) loss: 1.474310\n","(Iteration 181 / 200) loss: 1.473248\n","(Iteration 191 / 200) loss: 1.368022\n","(Epoch 5 / 5) train acc: 0.558000; val_acc: 0.365000\n","\n"],"name":"stdout"},{"output_type":"stream","text":["/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:39: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n","/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:42: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n","/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:45: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n","/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:49: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"],"name":"stderr"},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 1080x1080 with 3 Axes>"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"cdf_UeJK6e5A"},"source":["# RMSProp and Adam\n","RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n","\n","In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n","\n","**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n","\n","[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n","\n","[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."]},{"cell_type":"code","metadata":{"id":"PWBxZOWX6e5A","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1616348681202,"user_tz":-60,"elapsed":978,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"bbe6dd0f-6a4f-4a24-98f0-f19285cf400e"},"source":["# Test RMSProp implementation\n","from cs231n.optim import rmsprop\n","\n","N, D = 4, 5\n","w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n","dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n","cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n","\n","config = {'learning_rate': 1e-2, 'cache': cache}\n","next_w, _ = rmsprop(w, dw, config=config)\n","\n","expected_next_w = np.asarray([\n","  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n","  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n","  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n","  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n","expected_cache = np.asarray([\n","  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n","  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n","  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n","  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n","\n","# You should see relative errors around e-7 or less\n","print('next_w error: ', rel_error(expected_next_w, next_w))\n","print('cache error: ', rel_error(expected_cache, config['cache']))"],"execution_count":33,"outputs":[{"output_type":"stream","text":["next_w error:  9.524687511038133e-08\n","cache error:  2.6477955807156126e-09\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"aHUqK1Gx6e5B","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1616348690097,"user_tz":-60,"elapsed":960,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"4f6ee302-461f-45b2-e42a-262218628c34"},"source":["# Test Adam implementation\n","from cs231n.optim import adam\n","\n","N, D = 4, 5\n","w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n","dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n","m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n","v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n","\n","config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n","next_w, _ = adam(w, dw, config=config)\n","\n","expected_next_w = np.asarray([\n","  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n","  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n","  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n","  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n","expected_v = np.asarray([\n","  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n","  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n","  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n","  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n","expected_m = np.asarray([\n","  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n","  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n","  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n","  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n","\n","# You should see relative errors around e-7 or less\n","print('next_w error: ', rel_error(expected_next_w, next_w))\n","print('v error: ', rel_error(expected_v, config['v']))\n","print('m error: ', rel_error(expected_m, config['m']))"],"execution_count":34,"outputs":[{"output_type":"stream","text":["next_w error:  1.1395691798535431e-07\n","v error:  4.208314038113071e-09\n","m error:  4.214963193114416e-09\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"IKCXnhnW6e5B"},"source":["Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"]},{"cell_type":"code","metadata":{"id":"viZMbPdw6e5B","colab":{"base_uri":"https://localhost:8080/","height":1000},"executionInfo":{"status":"ok","timestamp":1612474682285,"user_tz":-60,"elapsed":11258,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"15493f1a-b5cb-41cc-eb00-d1c19bd34e73"},"source":["learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n","for update_rule in ['adam', 'rmsprop']:\n","  print('running with ', update_rule)\n","  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n","\n","  solver = Solver(model, small_data,\n","                  num_epochs=5, batch_size=100,\n","                  update_rule=update_rule,\n","                  optim_config={\n","                    'learning_rate': learning_rates[update_rule]\n","                  },\n","                  verbose=True)\n","  solvers[update_rule] = solver\n","  solver.train()\n","  print()\n","\n","plt.subplot(3, 1, 1)\n","plt.title('Training loss')\n","plt.xlabel('Iteration')\n","\n","plt.subplot(3, 1, 2)\n","plt.title('Training accuracy')\n","plt.xlabel('Epoch')\n","\n","plt.subplot(3, 1, 3)\n","plt.title('Validation accuracy')\n","plt.xlabel('Epoch')\n","\n","for update_rule, solver in list(solvers.items()):\n","  plt.subplot(3, 1, 1)\n","  plt.plot(solver.loss_history, 'o', label=update_rule)\n","  \n","  plt.subplot(3, 1, 2)\n","  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n","\n","  plt.subplot(3, 1, 3)\n","  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n","  \n","for i in [1, 2, 3]:\n","  plt.subplot(3, 1, i)\n","  plt.legend(loc='upper center', ncol=4)\n","plt.gcf().set_size_inches(15, 15)\n","plt.show()"],"execution_count":null,"outputs":[{"output_type":"stream","text":["running with  adam\n","(Iteration 1 / 200) loss: 2.683026\n","(Epoch 0 / 5) train acc: 0.133000; val_acc: 0.107000\n","(Iteration 11 / 200) loss: 2.094550\n","(Iteration 21 / 200) loss: 2.001838\n","(Iteration 31 / 200) loss: 1.916622\n","(Epoch 1 / 5) train acc: 0.314000; val_acc: 0.299000\n","(Iteration 41 / 200) loss: 1.849029\n","(Iteration 51 / 200) loss: 1.761948\n","(Iteration 61 / 200) loss: 1.622183\n","(Iteration 71 / 200) loss: 1.602142\n","(Epoch 2 / 5) train acc: 0.430000; val_acc: 0.336000\n","(Iteration 81 / 200) loss: 1.548003\n","(Iteration 91 / 200) loss: 1.679375\n","(Iteration 101 / 200) loss: 1.445859\n","(Iteration 111 / 200) loss: 1.460205\n","(Epoch 3 / 5) train acc: 0.484000; val_acc: 0.362000\n","(Iteration 121 / 200) loss: 1.419457\n","(Iteration 131 / 200) loss: 1.465910\n","(Iteration 141 / 200) loss: 1.618236\n","(Iteration 151 / 200) loss: 1.559929\n","(Epoch 4 / 5) train acc: 0.498000; val_acc: 0.347000\n","(Iteration 161 / 200) loss: 1.218347\n","(Iteration 171 / 200) loss: 1.018907\n","(Iteration 181 / 200) loss: 1.541438\n","(Iteration 191 / 200) loss: 1.284076\n","(Epoch 5 / 5) train acc: 0.561000; val_acc: 0.369000\n","\n","running with  rmsprop\n","(Iteration 1 / 200) loss: 2.592519\n","(Epoch 0 / 5) train acc: 0.116000; val_acc: 0.125000\n","(Iteration 11 / 200) loss: 2.126185\n","(Iteration 21 / 200) loss: 1.931993\n","(Iteration 31 / 200) loss: 1.833948\n","(Epoch 1 / 5) train acc: 0.375000; val_acc: 0.313000\n","(Iteration 41 / 200) loss: 1.801159\n","(Iteration 51 / 200) loss: 1.831144\n","(Iteration 61 / 200) loss: 1.593434\n","(Iteration 71 / 200) loss: 1.786832\n","(Epoch 2 / 5) train acc: 0.432000; val_acc: 0.342000\n","(Iteration 81 / 200) loss: 1.614097\n","(Iteration 91 / 200) loss: 1.610597\n","(Iteration 101 / 200) loss: 1.656030\n","(Iteration 111 / 200) loss: 1.586038\n","(Epoch 3 / 5) train acc: 0.487000; val_acc: 0.335000\n","(Iteration 121 / 200) loss: 1.409576\n","(Iteration 131 / 200) loss: 1.550687\n","(Iteration 141 / 200) loss: 1.539730\n","(Iteration 151 / 200) loss: 1.614167\n","(Epoch 4 / 5) train acc: 0.499000; val_acc: 0.367000\n","(Iteration 161 / 200) loss: 1.581322\n","(Iteration 171 / 200) loss: 1.454006\n","(Iteration 181 / 200) loss: 1.486930\n","(Iteration 191 / 200) loss: 1.463776\n","(Epoch 5 / 5) train acc: 0.516000; val_acc: 0.341000\n","\n"],"name":"stdout"},{"output_type":"stream","text":["/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:30: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n","/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:33: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n","/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:36: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n","/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:40: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"],"name":"stderr"},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 1080x1080 with 3 Axes>"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"tags":["pdf-inline"],"id":"3bYf8tz86e5B"},"source":["## Inline Question 3:\n","\n","AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n","\n","```\n","cache += dw**2\n","w += - learning_rate * dw / (np.sqrt(cache) + eps)\n","```\n","\n","John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n","\n","\n","## Answer: \n","- Using AdaGrad, the fact that updates becomes very small is due to its monotonicity. The latter is caused by the infinite update of the `cache` variable (although it's square-rooted when updating `w`, it will not change the fact that it's still incremented infinitely).\n","- No, Adam would not have the same issue. In fact, Adam is a smoothed version of **RMSprop**, in which the `cache` variable is *leaky*."]},{"cell_type":"markdown","metadata":{"id":"19iegKRb6e5C"},"source":["# Train a good model!\n","Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n","\n","If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n","\n","You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."]},{"cell_type":"code","metadata":{"scrolled":false,"id":"BlxVLk8i6e5C","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1616354514212,"user_tz":-60,"elapsed":2142989,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"54d4fd39-07ef-4506-9ab7-8d4e8a06074e"},"source":["best_model = None\n","################################################################################\n","# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n","# find batch/layer normalization and dropout useful. Store your best model in  #\n","# the best_model variable.                                                     #\n","################################################################################\n","# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n","\n","# To find the optimal parameter combination, we'll use a random search strategy.\n","# For that, define a random search function, which yields tuples of\n","# (hidden_size, hidden_dimension, dropout_p, weight_scale, lr)\n","# Note that the hard-coded low/high values for each parameter are changed (i.e. refined)\n","# during tests.\n","def random_search(sample_size):\n","  for _ in range(sample_size):\n","    hsize = np.random.randint(low=1, high=3)\n","    hdim = np.random.randint(low=300, high=500)\n","    dp = np.around(np.random.uniform(low=8, high=10) / 10, decimals=2)\n","    wscale = 10 ** np.random.uniform(low=-4, high=-3)\n","    lr = 10 ** np.random.uniform(low=-4, high=-3)\n","\n","    yield hsize, hdim, dp, wscale, lr\n","\n","# Initialize the best validation accuracy.\n","best_val_acc = 0.0\n","\n","# Batch size (bsize) is kept unchanged during the random search.\n","bsize = 100\n","\n","# Test 10 parameter combinations.\n","for i, params in enumerate(random_search(10)):\n","  hsize, hdim, dp, wscale, lr = params\n","\n","  # Define 'hdim' hidden layers with size 'hsize'\n","  hidden_layers = [hdim] * hsize\n","  model = FullyConnectedNet(hidden_layers, weight_scale=wscale,\n","                            normalization=\"batchnorm\", dropout=dp)\n","\n","  solver = Solver(model, data,\n","                  num_epochs=5, batch_size=bsize,\n","                  update_rule='adam',\n","                  optim_config={'learning_rate': lr},\n","                  verbose=False)\n","\n","  solver.train()\n","\n","  y_val_pred = np.argmax(model.loss(data['X_val']), axis=1)\n","  val_acc = (y_val_pred == data['y_val']).mean()\n","\n","  print('%2d) hsize=%1d | hdim=%3d | dp=%.2f | wscale=%.2e | lr=%.3e | val_acc=%.4f' % \n","        (i+1, hsize, hdim, dp, wscale, lr, val_acc))\n","\n","  if val_acc > best_val_acc:\n","    best_val_acc = val_acc\n","    best_model = model\n","\n","print('\\nBest validation accuracy: %.4f' % best_val_acc)\n","\n","# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n","################################################################################\n","#                              END OF YOUR CODE                                #\n","################################################################################"],"execution_count":9,"outputs":[{"output_type":"stream","text":[" 1) hsize=2 | hdim=393 | dp=0.95 | wscale=4.28e-04 | lr=1.299e-04 | val_acc=0.5510\n"," 2) hsize=2 | hdim=389 | dp=0.94 | wscale=1.01e-04 | lr=4.392e-04 | val_acc=0.5530\n"," 3) hsize=2 | hdim=473 | dp=0.83 | wscale=6.54e-04 | lr=1.789e-04 | val_acc=0.5590\n"," 4) hsize=1 | hdim=451 | dp=0.94 | wscale=2.58e-04 | lr=1.073e-04 | val_acc=0.5140\n"," 5) hsize=1 | hdim=480 | dp=0.91 | wscale=1.06e-04 | lr=7.362e-04 | val_acc=0.5240\n"," 6) hsize=2 | hdim=445 | dp=0.91 | wscale=2.04e-04 | lr=1.056e-04 | val_acc=0.5470\n"," 7) hsize=2 | hdim=499 | dp=0.86 | wscale=5.23e-04 | lr=3.167e-04 | val_acc=0.5610\n"," 8) hsize=1 | hdim=319 | dp=0.87 | wscale=7.32e-04 | lr=3.964e-04 | val_acc=0.5250\n"," 9) hsize=2 | hdim=323 | dp=0.91 | wscale=9.30e-04 | lr=4.006e-04 | val_acc=0.5630\n","10) hsize=1 | hdim=458 | dp=0.85 | wscale=1.48e-04 | lr=8.384e-04 | val_acc=0.5510\n","\n","Best validation accuracy: 0.5630\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"Fcd_y9uN6e5D"},"source":["# Test your model!\n","Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."]},{"cell_type":"code","metadata":{"id":"vmd3V6gg6e5D","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1616354515881,"user_tz":-60,"elapsed":1654,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"eca76537-21db-4e39-ee8c-c8ae634dd8ad"},"source":["y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n","y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n","print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n","print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"],"execution_count":10,"outputs":[{"output_type":"stream","text":["Validation set accuracy:  0.563\n","Test set accuracy:  0.535\n"],"name":"stdout"}]}]}